"""
AI配置功能模块，包含AI配置相关的UI和功能
"""
from PyQt5.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QGroupBox, QLabel, 
    QLineEdit, QComboBox, QCheckBox, QMessageBox
)
from PyQt5.QtCore import Qt, pyqtSignal

from app.ui.components.styled_button import StyledButton
from app.ui.components.styled_label import StyledLabel
from app.ui.components.toast import show_toast, Toast
from app.utils.logger import Logger

class AIConfigModule(QWidget):
    """
    AI配置功能模块类，包含AI配置相关的UI和功能
    """
    
    # 定义信号
    ai_config_updated = pyqtSignal(str, object)  # AI配置更新信号
    
    def __init__(self, parent=None):
        """
        初始化AI配置功能模块
        """
        super().__init__(parent)
        
        # 获取日志记录器
        self.logger = Logger.get_logger("ai_config_module")
        
        # 初始化成员变量
        self.token_input = None
        self.bot_combo = None
        self.stream_checkbox = None
        self.prompt_template = None
        self.saved_bot_id = None
        
        # 标记是否是用户手动选择
        self.is_user_selection = False
        
        # 初始化UI
        self._init_ui()
    
    def _init_ui(self):
        """
        初始化UI
        """
        # 创建主布局
        main_layout = QVBoxLayout(self)
        main_layout.setContentsMargins(0, 0, 0, 0)
        
        # 创建AI配置组
        self._create_ai_config_group(main_layout)
    
    def _create_ai_config_group(self, parent_layout):
        """
        创建AI配置组
        """
        ai_group = QGroupBox("AI配置")
        ai_layout = QVBoxLayout(ai_group)
        ai_layout.setContentsMargins(10, 10, 10, 10)  # 减小内边距
        
        # 所有元素放在同一行
        ai_row = QHBoxLayout()
        ai_row.setSpacing(10)  # 减小组件之间的间距
        
        # Token部分
        token_label = StyledLabel("Token:", size=StyledLabel.SMALL)
        token_label.setAlignment(Qt.AlignVCenter)
        token_label.setFixedWidth(40)  # 固定标签宽度
        
        self.token_input = QLineEdit()
        self.token_input.setPlaceholderText("请输入Token")
        self.token_input.setMinimumHeight(28)  # 设置最小高度
        # 添加回车事件处理
        self.token_input.returnPressed.connect(self._connect_coze)
        
        # 机器人列表部分
        bot_label = StyledLabel("机器人:", size=StyledLabel.SMALL)
        bot_label.setAlignment(Qt.AlignVCenter)
        bot_label.setFixedWidth(70)  # 固定标签宽度
        
        self.bot_combo = QComboBox()
        self.bot_combo.setMinimumHeight(28)  # 设置最小高度
        self.bot_combo.setMinimumWidth(150)  # 设置最小宽度
        # 初始状态为空
        self.bot_combo.clear()
        self.bot_combo.currentIndexChanged.connect(self._on_bot_selected)
        
        # 流式对话勾选框
        stream_label = StyledLabel("流式对话:", size=StyledLabel.SMALL)
        stream_label.setAlignment(Qt.AlignVCenter)
        stream_label.setFixedWidth(60)  # 固定标签宽度
        
        self.stream_checkbox = QCheckBox()
        self.stream_checkbox.setChecked(True)
        self.stream_checkbox.stateChanged.connect(self._on_stream_mode_changed)
        
        # 添加Token到水平布局
        ai_row.addWidget(token_label)
        ai_row.addWidget(self.token_input, 2)  # Token输入框占据更多空间
        
        # 添加间隔
        ai_row.addSpacing(10)  # 减小间隔
        
        # 添加机器人列表到水平布局
        ai_row.addWidget(bot_label)
        ai_row.addWidget(self.bot_combo, 1)
        
        # 添加间隔
        ai_row.addSpacing(10)  # 减小间隔
        
        # 添加流式对话勾选框到水平布局
        ai_row.addWidget(stream_label)
        ai_row.addWidget(self.stream_checkbox)
        
        # 添加到主布局
        ai_layout.addLayout(ai_row)
        
        parent_layout.addWidget(ai_group)
    
    def _connect_coze(self):
        """
        连接 Coze API
        """
        token = self.token_input.text().strip()
        if token:
            # 显示 Toast 提示
            self.logger.info("显示 Toast 提示：正在连接中...")
            show_toast(self, "正在连接中...", 3000, Toast.INFO)
            
            # 发送 token 更新信号
            self.ai_config_updated.emit("token", token)
        else:
            # 显示错误提示
            self.logger.error("Token不能为空")
            QMessageBox.warning(self, "错误", "Token不能为空")
    
    def _refresh_bots(self):
        """
        刷新机器人列表
        """
        self.ai_config_updated.emit("refresh_bots", None)
    
    def _on_bot_selected(self, index):
        """
        机器人选择改变事件处理
        
        @param index: 选中的索引
        """
        if index >= 0:
            # 获取选中的机器人ID和名称
            bot_id = self.bot_combo.itemData(index)
            display_name = self.bot_combo.itemText(index)
            
            if bot_id:
                self.logger.info(f"选择机器人: {display_name}, ID: {bot_id}")
                # 发送机器人选择信号
                self.ai_config_updated.emit("bot_id", {"bot_id": bot_id, "display_name": display_name})
                
                # 始终创建新会话，无论是用户手动选择还是程序自动选择
                self.logger.info(f"选择机器人 {display_name}，创建新会话")
                self._create_conversation(bot_id)
    
    def _create_conversation(self, bot_id=None):
        """
        创建新会话
        
        @param bot_id: 机器人ID，如果为None则使用当前选中的机器人
        """
        if bot_id is None:
            # 获取当前选中的机器人ID
            index = self.bot_combo.currentIndex()
            if index >= 0:
                bot_id = self.bot_combo.itemData(index)
        
        if bot_id:
            self.logger.info(f"为机器人 {bot_id} 创建新会话")
            # 发送创建会话信号
            self.ai_config_updated.emit("create_conversation", bot_id)
    
    def _on_stream_mode_changed(self, state):
        """
        流式对话模式改变事件处理
        
        @param state: 勾选状态
        """
        # 发送流式对话模式更新信号
        self.ai_config_updated.emit("stream_mode", state == Qt.Checked)
    
    def update_bot_list(self, bots):
        """
        更新机器人列表
        
        @param bots: 机器人列表
        """
        if not bots:
            self.logger.info("机器人列表为空")
            return
        
        self.logger.info(f"更新机器人列表，共 {len(bots)} 个机器人")
        
        # 清空当前列表
        self.bot_combo.clear()
        
        # 记录保存的机器人索引
        saved_bot_index = -1
        
        # 添加机器人到下拉框
        for i, bot in enumerate(bots):
            # 处理不同格式的机器人数据
            if isinstance(bot, dict):
                # 从AI服务返回的格式
                bot_id = bot.get("bot_id")
                display_name = bot.get("display_name") or bot.get("bot_name", "未命名机器人")
                
                if bot_id:
                    self.logger.info(f"添加机器人: {display_name}, ID: {bot_id}")
                    self.bot_combo.addItem(display_name, bot_id)
                    
                    # 如果是保存的机器人，记录索引
                    if bot_id == self.saved_bot_id:
                        self.logger.info(f"找到保存的机器人: {display_name}, 索引: {i}")
                        saved_bot_index = i  # 直接使用当前索引
        
        # 如果有保存的机器人，选中它；否则选择第一个
        if saved_bot_index >= 0:
            self.logger.info(f"选中保存的机器人，索引: {saved_bot_index}")
        else:
            # 如果没有找到保存的机器人但列表不为空，选择第一个
            if self.bot_combo.count() > 0:
                saved_bot_index = 0
                self.logger.info(f"未找到保存的机器人ID: {self.saved_bot_id}，默认选择第一个")
            else:
                self.logger.warning(f"未找到保存的机器人ID: {self.saved_bot_id}，且列表为空")
                return
                
        try:
            # 暂时断开信号连接，避免触发_on_bot_selected
            self.bot_combo.currentIndexChanged.disconnect(self._on_bot_selected)
            # 设置选中项
            self.bot_combo.setCurrentIndex(saved_bot_index)
            # 重新连接信号
            self.bot_combo.currentIndexChanged.connect(self._on_bot_selected)
            
            # 手动触发选择事件，但不创建新会话
            bot_id = self.bot_combo.itemData(saved_bot_index)
            display_name = self.bot_combo.itemText(saved_bot_index)
            
            if bot_id:
                self.logger.info(f"选择机器人: {display_name}, ID: {bot_id}")
                # 发送机器人选择信号
                self.ai_config_updated.emit("bot_id", {"bot_id": bot_id, "display_name": display_name})
                
                # 注意：这里不再自动创建新会话
                # self._create_conversation(bot_id)
        except Exception as e:
            self.logger.error(f"选中机器人失败: {str(e)}")
    
    def set_ai_config(self, config):
        """
        设置 AI 配置
        
        @param config: AI 配置字典
        """
        # 设置 Token
        if "token" in config:
            saved_token = config["token"]
            if saved_token:
                self.logger.info(f"从配置加载Token: {saved_token[:5]}...")
                self.token_input.setText(saved_token)
        
        # 设置流式对话模式
        if "stream_mode" in config:
            self.stream_checkbox.setChecked(config["stream_mode"])
            
        # 记录保存的bot_id，等待列表加载后再设置选中状态
        self.saved_bot_id = config.get("bot_id")
        
        self.logger.info(f"保存的配置: bot_id={self.saved_bot_id}")
    
    def set_token(self, token):
        """
        设置Token
        
        @param token: Token字符串
        """
        if self.token_input and token:
            self.token_input.setText(token)
            self.logger.info("已设置Token")
    
    def set_bot(self, bot_id, bot_name=None):
        """
        设置机器人
        
        @param bot_id: 机器人ID
        @param bot_name: 机器人名称
        """
        if not self.bot_combo or not bot_id:
            return
            
        # 保存机器人ID，用于后续选择
        self.saved_bot_id = bot_id
        
        # 如果有名称，尝试在下拉框中找到对应项
        if bot_name:
            for i in range(self.bot_combo.count()):
                if self.bot_combo.itemText(i) == bot_name and self.bot_combo.itemData(i) == bot_id:
                    # 暂时断开信号连接，避免触发_on_bot_selected
                    self.bot_combo.currentIndexChanged.disconnect(self._on_bot_selected)
                    # 设置选中项
                    self.bot_combo.setCurrentIndex(i)
                    # 重新连接信号
                    self.bot_combo.currentIndexChanged.connect(self._on_bot_selected)
                    self.logger.info(f"已设置机器人: {bot_name} ({bot_id})")
                    return
        
        self.logger.info(f"已保存机器人ID: {bot_id}，但未在列表中找到对应项")
    
    def set_stream_mode(self, enabled):
        """
        设置流式对话模式
        
        @param enabled: 是否启用
        """
        if self.stream_checkbox:
            # 暂时断开信号连接，避免触发_on_stream_mode_changed
            self.stream_checkbox.stateChanged.disconnect(self._on_stream_mode_changed)
            # 设置勾选状态
            self.stream_checkbox.setChecked(enabled)
            # 重新连接信号
            self.stream_checkbox.stateChanged.connect(self._on_stream_mode_changed)
            self.logger.info(f"已设置流式对话模式: {enabled}") 